home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / PROGRAM / LDB171.ARJ / FBINDER.HPP < prev    next >
C/C++ Source or Header  |  1992-05-12  |  9KB  |  391 lines
  1. /*
  2.     FBinder.hpp -- Loose Data Binder v 1.7:
  3.         container class "form."
  4.  
  5.     (C) Copyright 1992  John W. Small
  6.     All rights reserved
  7.  
  8.     PSW / Power SoftWare
  9.     P.O. Box 10072
  10.     McLean, Virginia 22102 8072 USA
  11.     (703) 759-3838
  12.  
  13.     If you want strong type checking and your compiler
  14.     doesn't support C++ templates, include the
  15.     following lines in your source code:
  16.  
  17.  
  18.         #define  FType        int
  19.         #define  FBinder    IntBdr
  20.         #define  FBindeR    IntBdR
  21.         #include "fbinder.hpp"
  22.  
  23.  
  24.     Replace "int" with the name of the data type you 
  25.     want bound within the Binder and "IntBdr" with an 
  26.     appropriate name for your new type of Binder and 
  27.     "IntBdR" with the name of the pointer type to this 
  28.     new Binder type.  FType must have the following 
  29.     properties to use this approach:
  30.  
  31.  
  32.         default constructor
  33.         copy initializer constructor,
  34.             i.e. TYPE(TYPE&)
  35.         destructor
  36.         assignment operator, i.e. operator=()
  37.         ostream& operator<<(ostream&,TYPE&)
  38.         istream& operator>>(istream&,TYPE&)
  39.  
  40.  
  41.     If not you must instead clone this file and 
  42.     the fbinder.cpp file and use your editor to globally
  43.  
  44.  
  45.         replace:    with something like:
  46.  
  47.         FType        int
  48.         FBinder        IntBdr
  49.         FBindeR        IntBdR
  50.  
  51.  
  52.     Suppose you called your two new files intbdr.hpp
  53.     and intbdr.cpp.  Your can then further edit 
  54.     intbdr.cpp to give your data type the appropriate
  55.     semantics:
  56.  
  57.         edit:        yielding properties:
  58.  
  59.         Dassign        assignment operator
  60.         Dnew        copy initializer
  61.         Ddelete        destructor
  62.         Dstore        stream insert
  63.         Dload        stream extract, default
  64.                     construct
  65.  
  66. */
  67.  
  68.  
  69. #ifdef  FType
  70. #undef  FBinder_HPP
  71. #endif
  72.  
  73.  
  74. #ifndef FBinder_HPP
  75. #define FBinder_HPP
  76.  
  77.  
  78. #ifndef BINDER_HPP
  79. #include "binder.hpp"
  80. #endif
  81.  
  82.  
  83. typedef class FBinder * FBindeR;
  84. #define FBindeR0  ((FBindeR)0)
  85.  
  86. class FBinder : Binder {
  87.  
  88.  
  89. private:
  90.  
  91.     /*  FBinder-declared data members  */
  92.  
  93.     int      initData(
  94.             /* FBinder-declared data
  95.             member initializers */
  96.          );
  97.  
  98. protected:
  99.  
  100.     FBinder  (initVFTs)
  101.             : Binder(initVFTsOnly) {}
  102.     Binder:: destruct;
  103.     virtual  voiD Dassign(voiD D, const voiD S);
  104.     virtual  voiD Dnew(const voiD D);
  105.     virtual  void Ddelete(voiD D);
  106.     Binder:: Dattach;
  107.     Binder:: Ddetach;
  108.     Binder:: sberror;
  109.     Binder:: berror;
  110.     virtual  void Dstore(ostream& os, voiD D);
  111.     virtual  voiD Dload(istream& is);
  112.     virtual  void store(ostream& os);
  113.     static   FBindeR load(istream& is, FBindeR thiS);
  114.     Binder:: vload;
  115.     friend   ostream& operator<<(ostream&,
  116.             FBinder&);
  117.     friend   istream& operator>>(istream&,
  118.             FBindeR&);
  119.     
  120.  
  121. public:
  122.  
  123.  
  124.  
  125. /*  Constructors and destructor  */
  126.  
  127.     FBinder
  128.         (
  129.         /*
  130.             FBinder-declared data member
  131.             initializers go here!
  132.         */
  133.         unsigned flags = BDR_BIND_ONLY,
  134.         unsigned maxNodes = BDR_MAXNODES,
  135.         unsigned limit = BDR_LIMIT,
  136.         unsigned delta = BDR_DELTA) :
  137.         Binder(flags,maxNodes,limit,delta)
  138.         {
  139.             (void) initData(
  140.                 /* FBinder-declared data
  141.                 member initializers */
  142.                 );
  143.         }
  144.     FBinder
  145.         (FType * argv[],
  146.         unsigned argc = 0,
  147.         unsigned flags = BDR_BIND_ONLY)
  148.         : Binder((voiDV)argv,argc,flags) {}
  149.     FBinder
  150.         (const char *filename)
  151.         : Binder(initVFTsOnly)
  152.         { (void) vload(filename,(BDRsloaD)
  153.         FBinder::load,this); }
  154.     Binder::save;
  155.     FType ** vector()
  156.             { return (FType **)Binder::
  157.             vector(); }
  158.     virtual ~FBinder()  { FBinder::destruct(); }
  159.  
  160.  
  161. /*  Housekeeping Primitives  */
  162.  
  163.     Binder:: Limit;
  164.     Binder:: setLimit;
  165.     Binder:: pack;
  166.     Binder:: Delta;
  167.     Binder:: setDelta;
  168.     Binder:: Nodes;
  169.     Binder:: MaxNodes;
  170.     Binder:: setMaxNodes;
  171.     Binder:: vacancy;
  172.     Binder:: vacancyNonElastic;
  173.     Binder:: Flags;
  174.     Binder:: setFlags;
  175.     Binder:: resetFlags;
  176.     FBinder&  operator<<(FBinder& (*manipulator)
  177.             (FBinder&)) { return 
  178.             (manipulator? (*manipulator)
  179.             (*this)    : *this); }
  180.  
  181.  
  182.  
  183. /*  Elastic Array Primitives  */
  184.  
  185.     FType *   atIns(unsigned n, FType * D)
  186.             { return (FType *)Binder::
  187.             atIns(n,(voiD)D); }
  188.     FType *   atInsNew(unsigned n, const FType * D)
  189.             { return (FType *)Binder::
  190.             atInsNew(n,(const voiD)D); }
  191.     FType *   atRmv(unsigned n)
  192.             { return (FType *)Binder::
  193.             atRmv(n); }
  194.     Binder::  allRmv;
  195.     Binder::  atDel;
  196.     FType *   atDelAsg(unsigned n, FType * D)
  197.             { return (FType *)Binder::
  198.             atDelAsg(n,(voiD)D); }
  199.     Binder::  allDel;
  200.     FType *   atPut(unsigned n, FType * D)
  201.             { return (FType *)Binder::
  202.             atPut(n,(voiD)D); }
  203.     FType *   atPutNew(unsigned n, const FType * D)
  204.             { return (FType *)Binder::
  205.             atPutNew(n,(const voiD)D); }
  206.     FType *   atPutAsg(unsigned n, const FType * D)
  207.             { return (FType *)Binder::
  208.             atPutAsg(n,(const voiD)D); }
  209.     FType *   atGet(unsigned n)
  210.             { return (FType *)Binder::
  211.             atGet(n); }
  212.     FType *   operator[](unsigned n)
  213.             { return atGet(n); }
  214.     FType *   atGetAsg(unsigned n, FType * D)
  215.             { return (FType *)Binder::
  216.             atGetAsg(n,(voiD) D); }
  217.     FType *   atXchg(unsigned n, FType * D)
  218.             { return (FType *)Binder::
  219.             atXchg(n,(voiD) D); }
  220.     unsigned  index(const FType * D)
  221.             { return Binder::
  222.             index((const voiD)D); }
  223.     Binder::  forEach;
  224.  
  225.  
  226. /*  Stack - Deque - Queue Primitives  */
  227.  
  228.     FType *   push(FType * D)
  229.             { return (FType *)Binder::
  230.             push((voiD) D); }
  231.     FType *   pushNew(const FType * D)
  232.             { return (FType *)Binder::
  233.             pushNew((const voiD)D); }
  234.     FType *   pop()
  235.             { return (FType *)Binder::
  236.             pop(); }
  237.     FBinder&  operator>>(FType *& D)
  238.             { D = atRmv(0); return *this; }
  239.     Binder::  popDel;
  240.     FType *   popDelAsg(FType * D)
  241.             { return (FType *)Binder::
  242.             popDelAsg((voiD)D); }
  243.     FType *   top()
  244.             { return (FType *)Binder::
  245.                 top(); }
  246.     FType *   topAsg(FType * D)
  247.             { return (FType *)Binder::
  248.             topAsg((voiD)D); }
  249.     FType *   insQ(FType * D)
  250.             { return (FType *)Binder::
  251.             insQ((voiD)D); }
  252.     FBinder&  operator<<(FType * D)
  253.             { atIns(Nodes(),D); return *this; }
  254.     FType *   insQNew(const FType * D)
  255.             { return (FType *)Binder::
  256.             insQNew((const voiD)D); }
  257.     FType *   unQ()
  258.             { return (FType *)Binder::
  259.             unQ(); }
  260.     Binder::  unQDel;
  261.     FType *   unQDelAsg(FType * D)
  262.             { return (FType *)Binder::
  263.             unQDelAsg((voiD)D); }
  264.     FType *   rear()
  265.             { return (FType *)Binder::
  266.                 rear(); }
  267.     FType *   rearAsg(FType * D)
  268.             { return (FType *)Binder::
  269.             rearAsg((voiD)D); }
  270.  
  271.  
  272. /*  List (single and double linked) Primitives  */
  273.  
  274.     Binder::  CurNode;
  275.     Binder::  setCurNode;
  276.     FType *   ins(FType * D)
  277.             { return (FType *)Binder::
  278.             ins((voiD)D); }
  279.     FType *   insNew(const FType * D)
  280.             { return (FType *)Binder::
  281.             insNew((const voiD)D); }
  282.     FType *   rmv()
  283.             { return (FType *)Binder::
  284.             rmv(); }
  285.     Binder::  del;
  286.     FType *   delAsg(FType * D)
  287.             { return (FType *)Binder::
  288.             delAsg((voiD)D); }
  289.     FType *   put(FType * D)
  290.             { return (FType *)Binder::
  291.             put((voiD)D); }
  292.     FType *   putNew(const FType * D)
  293.             { return (FType *)Binder::
  294.             putNew((const voiD)D); }
  295.     FType *   putAsg(const FType * D)
  296.             { return (FType *)Binder::
  297.             putAsg((const voiD)D); }
  298.     FType *   get()
  299.             { return (FType *)Binder::
  300.             get(); }
  301.     operator  FType *()  { return get(); }
  302.     FType *   getAsg(FType * D)
  303.             { return (FType *)Binder::
  304.             getAsg((voiD)D); }
  305.     FType *   next()
  306.             { return (FType *)Binder::
  307.             next(); }
  308.     FType *   operator++()
  309.             { return next(); }
  310.     FType *   nextAsg(FType * D)
  311.             { return (FType *)Binder::
  312.             nextAsg((voiD)D); }
  313.     FType *   prev()
  314.             { return (FType *)Binder::
  315.             prev(); }
  316.     FType *   operator--()
  317.             { return prev(); }
  318.     FType *   prevAsg(FType * D)
  319.             { return (FType *)Binder::
  320.             prevAsg((voiD)D); }
  321.  
  322.     FType *   firstThat(BDRdetecT B, voiD M = voiD0)
  323.             { return (FType *)Binder::
  324.             firstThat(B,M); }
  325.     FType *   lastThat(BDRdetecT B, voiD M = voiD0)
  326.             { return (FType *)Binder::
  327.             lastThat(B,M); }
  328.  
  329.  
  330. /*  Priority Q, Set, Bag, Dictionary, Sort Primitives  */
  331.  
  332.     Binder::  Sorted;
  333.     Binder::  unSort;
  334.     Binder::  setComP;
  335.     Binder::  ComP;
  336.     Binder::  sort;
  337.     FType *   insSort(FType * D)
  338.             { return (FType *)Binder::
  339.             insSort((voiD)D); }
  340.     FType *   insSortNew(const FType * D)
  341.             { return (FType *)Binder::
  342.             insSortNew((const voiD)D); }
  343.     FType *   insUnique(FType * D)
  344.             { return (FType *)Binder::
  345.             insUnique((voiD)D); }
  346.     FType *   insUniqueNew(const FType * D)
  347.             { return (FType *)Binder::
  348.             insUniqueNew((const voiD)D); }
  349.     FType *   findFirst(const FType * K)
  350.             { return (FType *)Binder::
  351.             findFirst((const voiD)K); }
  352.     FType *   findNext(const FType * K)
  353.             { return (FType *)Binder::
  354.             findNext((const voiD)K); }
  355.     FType *   findLast (const FType * K)
  356.             { return (FType *)Binder::
  357.             findLast((const voiD)K); }
  358.     FType *   findPrev(const FType * K)
  359.             { return (FType *)Binder::
  360.             findPrev((const voiD)K); }
  361.     unsigned  findAll(const FType * K)
  362.             { return Binder::
  363.             findAll((const voiD)K); }
  364.  
  365.  
  366.  
  367. };    /*  class FBinder  */
  368.  
  369.  
  370. inline ostream& operator<<(ostream& os, FBinder& b)
  371.     {
  372.         if (b.Flags(BDR_DSTORE))
  373.             b.store(os);
  374.         return os;
  375.     }
  376.     
  377. inline istream& operator>>(istream& is, FBindeR& B)
  378.         { B = FBinder::
  379.             load(is,FBindeR0);
  380.             return is; }
  381.  
  382.  
  383. #endif  /*  FBinder_HPP  */
  384.  
  385.  
  386. #ifdef  FType
  387. #include "fbinder.cpp"
  388. #undef  FType
  389. #undef  FBinder
  390. #undef  FBindeR
  391. #endif